{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Batch Normalization\n",
    "One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. One idea along these lines is batch normalization which was recently proposed by [3].\n",
    "\n",
    "The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n",
    "\n",
    "The authors of [3] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [3] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n",
    "\n",
    "It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n",
    "\n",
    "[3] Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
    "Internal Covariate Shift\", ICML 2015."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting future\n",
      "Installing collected packages: future\n",
      "Successfully installed future-0.17.1\n"
     ]
    }
   ],
   "source": [
    "!pip install future"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "run the following from the cs231n directory and try again:\n",
      "python setup.py build_ext --inplace\n",
      "You may also need to restart your iPython kernel\n"
     ]
    }
   ],
   "source": [
    "# As usual, a bit of setup\n",
    "from __future__ import print_function\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "  \"\"\" returns relative error \"\"\"\n",
    "  return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:  (49000, 3, 32, 32)\n",
      "y_train:  (49000,)\n",
      "X_val:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.items():\n",
    "  print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Batch normalization: Forward\n",
    "In the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before batch normalization:\n",
      "  means:  [ -2.3814598  -13.18038246   1.91780462]\n",
      "  stds:  [27.18502186 34.21455511 37.68611762]\n",
      "After batch normalization (gamma=1, beta=0)\n",
      "  mean:  [ 1.33226763e-17 -3.94129174e-17  3.29597460e-17]\n",
      "  std:  [0.99999999 1.         1.        ]\n",
      "After batch normalization (nontrivial gamma, beta)\n",
      "  means:  [11. 12. 13.]\n",
      "  stds:  [0.99999999 1.99999999 2.99999999]\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after batch normalization\n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before batch normalization:')\n",
    "print('  means: ', a.mean(axis=0))\n",
    "print('  stds: ', a.std(axis=0))\n",
    "\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After batch normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = batchnorm_forward(a, np.ones(D3), np.zeros(D3), {'mode': 'train'})\n",
    "print('  mean: ', a_norm.mean(axis=0))\n",
    "print('  std: ', a_norm.std(axis=0))\n",
    "\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "gamma = np.asarray([1.0, 2.0, 3.0])\n",
    "beta = np.asarray([11.0, 12.0, 13.0])\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print('After batch normalization (nontrivial gamma, beta)')\n",
    "print('  means: ', a_norm.mean(axis=0))\n",
    "print('  stds: ', a_norm.std(axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After batch normalization (test-time):\n",
      "  means:  [-0.03927354 -0.04349152 -0.10452688]\n",
      "  stds:  [1.01531428 1.01238373 0.97819988]\n"
     ]
    }
   ],
   "source": [
    "# Check the test-time forward pass by running the training-time\n",
    "# forward pass many times to warm up the running averages, and then\n",
    "# checking the means and variances of activations after a test-time\n",
    "# forward pass.\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "for t in range(50):\n",
    "  X = np.random.randn(N, D1)\n",
    "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "  batchnorm_forward(a, gamma, beta, bn_param)\n",
    "bn_param['mode'] = 'test'\n",
    "X = np.random.randn(N, D1)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "# Means should be close to zero and stds close to one, but will be\n",
    "# noisier than training-time forward passes.\n",
    "print('After batch normalization (test-time):')\n",
    "print('  means: ', a_norm.mean(axis=0))\n",
    "print('  stds: ', a_norm.std(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Batch Normalization: backward\n",
    "Now implement the backward pass for batch normalization in the function `batchnorm_backward`.\n",
    "\n",
    "To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n",
    "\n",
    "Once you have finished, run the following to numerically check your backward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.7029258328157158e-09\n",
      "dgamma error:  7.420414216247087e-13\n",
      "dbeta error:  2.8795057655839487e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
    "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
    "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Batch Normalization: alternative backward (OPTIONAL, +3 points extra credit)\n",
    "In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For the sigmoid function, it turns out that you can derive a very simple formula for the backward pass by simplifying gradients on paper.\n",
    "\n",
    "Surprisingly, it turns out that you can also derive a simple expression for the batch normalization backward pass if you work out derivatives on paper and simplify. After doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster.\n",
    "\n",
    "NOTE: This part of the assignment is entirely optional, but we will reward 3 points of extra credit if you can complete it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx difference:  9.20004371222927e-13\n",
      "dgamma difference:  0.0\n",
      "dbeta difference:  0.0\n",
      "speedup: 1.62x\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D = 100, 500\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "\n",
    "t1 = time.time()\n",
    "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
    "t2 = time.time()\n",
    "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
    "t3 = time.time()\n",
    "\n",
    "print('dx difference: ', rel_error(dx1, dx2))\n",
    "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
    "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
    "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "## Fully Connected Nets with Batch Normalization\n",
    "Now that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs2312n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n",
    "\n",
    "Concretely, when the flag `use_batchnorm` is `True` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n",
    "\n",
    "HINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.302585092994046\n",
      "W1 relative error: 0.00e+00\n",
      "W2 relative error: 0.00e+00\n",
      "W3 relative error: 0.00e+00\n",
      "b1 relative error: 0.00e+00\n",
      "b2 relative error: 0.00e+00\n",
      "b3 relative error: 6.99e-11\n",
      "\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  7.053051653751987\n",
      "W1 relative error: 1.00e+00\n",
      "W2 relative error: 1.00e+00\n",
      "W3 relative error: 1.00e+00\n",
      "b1 relative error: 0.00e+00\n",
      "b2 relative error: 0.00e+00\n",
      "b3 relative error: 6.99e-11\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64,\n",
    "                            use_batchnorm=True)\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
    "    ######## if rel_error(grad_num, grads[name]) > 0.5: print(grad_num,grads[name])  # why W rel_err is 1?\n",
    "  if reg == 0: print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Batchnorm for deep networks\n",
    "Run the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 200) loss: 2.340975\n",
      "(Epoch 0 / 10) train acc: 0.105000; val_acc: 0.111000\n",
      "(Epoch 1 / 10) train acc: 0.300000; val_acc: 0.243000\n",
      "(Epoch 2 / 10) train acc: 0.432000; val_acc: 0.315000\n",
      "(Epoch 3 / 10) train acc: 0.473000; val_acc: 0.306000\n",
      "(Epoch 4 / 10) train acc: 0.560000; val_acc: 0.333000\n",
      "(Epoch 5 / 10) train acc: 0.592000; val_acc: 0.318000\n",
      "(Epoch 6 / 10) train acc: 0.611000; val_acc: 0.312000\n",
      "(Epoch 7 / 10) train acc: 0.678000; val_acc: 0.331000\n",
      "(Epoch 8 / 10) train acc: 0.698000; val_acc: 0.321000\n",
      "(Epoch 9 / 10) train acc: 0.780000; val_acc: 0.327000\n",
      "(Epoch 10 / 10) train acc: 0.768000; val_acc: 0.307000\n",
      "(Iteration 1 / 200) loss: 2.302332\n",
      "(Epoch 0 / 10) train acc: 0.123000; val_acc: 0.130000\n",
      "(Epoch 1 / 10) train acc: 0.264000; val_acc: 0.212000\n",
      "(Epoch 2 / 10) train acc: 0.320000; val_acc: 0.298000\n",
      "(Epoch 3 / 10) train acc: 0.343000; val_acc: 0.275000\n",
      "(Epoch 4 / 10) train acc: 0.397000; val_acc: 0.318000\n",
      "(Epoch 5 / 10) train acc: 0.445000; val_acc: 0.314000\n",
      "(Epoch 6 / 10) train acc: 0.487000; val_acc: 0.339000\n",
      "(Epoch 7 / 10) train acc: 0.557000; val_acc: 0.306000\n",
      "(Epoch 8 / 10) train acc: 0.607000; val_acc: 0.326000\n",
      "(Epoch 9 / 10) train acc: 0.622000; val_acc: 0.330000\n",
      "(Epoch 10 / 10) train acc: 0.672000; val_acc: 0.301000\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [100, 100, 100, 100, 100]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2\n",
    "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=True)\n",
    "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=False)\n",
    "\n",
    "bn_solver = Solver(bn_model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=200)\n",
    "bn_solver.train()\n",
    "\n",
    "solver = Solver(model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=200)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/lib/python3.6/site-packages/matplotlib/figure.py:98: MatplotlibDeprecationWarning: \n",
      "Adding an axes using the same arguments as a previous axes currently reuses the earlier instance.  In a future version, a new instance will always be created and returned.  Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n",
      "  \"Adding an axes using the same arguments as a previous axes \"\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Training loss')\n",
    "plt.xlabel('Iteration')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Training accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Validation accuracy')\n",
    "plt.xlabel('Epoch')\n",
    "\n",
    "plt.subplot(3, 1, 1)\n",
    "plt.plot(solver.loss_history, 'o', label='baseline')\n",
    "plt.plot(bn_solver.loss_history, 'o', label='batchnorm')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.plot(solver.train_acc_history, '-o', label='baseline')\n",
    "plt.plot(bn_solver.train_acc_history, '-o', label='batchnorm')\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.plot(solver.val_acc_history, '-o', label='baseline')\n",
    "plt.plot(bn_solver.val_acc_history, '-o', label='batchnorm')\n",
    "  \n",
    "for i in [1, 2, 3]:\n",
    "  plt.subplot(3, 1, i)\n",
    "  plt.legend(loc='upper center', ncol=4)\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Batch normalization and initialization\n",
    "We will now run a small experiment to study the interaction of batch normalization and weight initialization.\n",
    "\n",
    "The first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running weight scale 1 / 20\n",
      "Running weight scale 2 / 20\n",
      "Running weight scale 3 / 20\n",
      "Running weight scale 4 / 20\n",
      "Running weight scale 5 / 20\n",
      "Running weight scale 6 / 20\n",
      "Running weight scale 7 / 20\n",
      "Running weight scale 8 / 20\n",
      "Running weight scale 9 / 20\n",
      "Running weight scale 10 / 20\n",
      "Running weight scale 11 / 20\n",
      "Running weight scale 12 / 20\n",
      "Running weight scale 13 / 20\n",
      "Running weight scale 14 / 20\n",
      "Running weight scale 15 / 20\n",
      "Running weight scale 16 / 20\n",
      "Running weight scale 17 / 20\n",
      "Running weight scale 18 / 20\n",
      "Running weight scale 19 / 20\n",
      "Running weight scale 20 / 20\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "bn_solvers = {}\n",
    "solvers = {}\n",
    "weight_scales = np.logspace(-4, 0, num=20)\n",
    "for i, weight_scale in enumerate(weight_scales):\n",
    "  print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
    "  bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=True)\n",
    "  model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, use_batchnorm=False)\n",
    "\n",
    "  bn_solver = Solver(bn_model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  bn_solver.train()\n",
    "  bn_solvers[weight_scale] = bn_solver\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  solver.train()\n",
    "  solvers[weight_scale] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false,
    "deletable": true,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x1080 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results of weight scale experiment\n",
    "best_train_accs, bn_best_train_accs = [], []\n",
    "best_val_accs, bn_best_val_accs = [], []\n",
    "final_train_loss, bn_final_train_loss = [], []\n",
    "\n",
    "for ws in weight_scales:\n",
    "  best_train_accs.append(max(solvers[ws].train_acc_history))\n",
    "  bn_best_train_accs.append(max(bn_solvers[ws].train_acc_history))\n",
    "  \n",
    "  best_val_accs.append(max(solvers[ws].val_acc_history))\n",
    "  bn_best_val_accs.append(max(bn_solvers[ws].val_acc_history))\n",
    "  \n",
    "  final_train_loss.append(np.mean(solvers[ws].loss_history[-100:]))\n",
    "  bn_final_train_loss.append(np.mean(bn_solvers[ws].loss_history[-100:]))\n",
    "  \n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Best val accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best val accuracy')\n",
    "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
    "plt.legend(ncol=2, loc='lower right')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Best train accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best training accuracy')\n",
    "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Final training loss vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Final training loss')\n",
    "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "plt.gca().set_ylim(1.0, 3.5)\n",
    "\n",
    "plt.gcf().set_size_inches(10, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Question:\n",
    "Describe the results of this experiment, and try to give a reason why the experiment gave the results that it did."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "deletable": true,
    "editable": true
   },
   "source": [
    "# Answer:\n",
    "The batchnorm version is more tolerant on weight scales."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
